package com.mmd.core.result;

import com.mmd.core.enums.BaseEnum;
import com.mmd.core.enums.ResultEnum;
import com.mmd.core.pojo.result.PageInfo;
import com.mmd.core.pojo.result.Pages;
import com.mmd.core.pojo.vo.BaseVO;
import com.mmd.core.pojo.vo.MultiVO;
import com.mmd.core.pojo.vo.PageVO;
import com.mmd.core.pojo.vo.SingleVO;
import io.swagger.annotations.ApiModel;
import lombok.Data;

import java.util.Collection;

@Data
@ApiModel(value = "响应数据处理类")
public class Result {

    /**
     * 操作成功
     */
    public static BaseVO success()
    {
        return custom(ResultEnum.SUCCESS.getCode(),ResultEnum.SUCCESS.getMessage());
    }

    /**
     * 操作成功
     * @param message 提示信息
     */
    public static BaseVO success(String message)
    {
        return custom(ResultEnum.SUCCESS.getCode(),message);
    }

    /**
     * 操作失败
     */
    public static BaseVO fail()
    {
        return custom(ResultEnum.FAIL.getCode(),ResultEnum.FAIL.getMessage());
    }

    /**
     * 操作失败
     * @param message 提示信息
     */
    public static BaseVO fail(String message)
    {
        return custom(ResultEnum.FAIL.getCode(),message);
    }

    /**
     * 成功或失败
     * @param res boolean
     */
    public static BaseVO successOrFail(boolean res)
    {
        return successOrFail(res,success().getMessage(),fail().getMessage());
    }

    /**
     * 成功或失败
     * @param res int
     */
    public static BaseVO successOrFail(int res)
    {
        return successOrFail(res > 0,success().getMessage(),fail().getMessage());
    }

    /**
     * 成功或失败
     * @param res int
     * @param successMessage 成功提示语
     * @param failMessage 失败提示语
     */
    public static BaseVO successOrFail(int res,String successMessage,String failMessage)
    {
        return successOrFail(res > 0,successMessage,failMessage);
    }

    /**
     * 成功或失败
     * @param res boolean
     * @param successMessage 成功提示语
     * @param failMessage 失败提示语
     */
    public static BaseVO successOrFail(boolean res,String successMessage,String failMessage)
    {
        if(res) return success(successMessage);
        return fail(failMessage);
    }

    /**
     * 自定义响应数据
     * @param baseEnum 枚举
     */
    public static BaseVO custom(BaseEnum baseEnum){
        return custom(baseEnum.getCode(),baseEnum.getMessage());
    }

    /**
     * 自定义响应数据
     * @param code 状态码
     * @param message 提示信息
     */
    public static BaseVO custom(String code,String message){
        BaseVO baseVO = new BaseVO();
        baseVO.setCode(code);
        baseVO.setMessage(message);
        return baseVO;
    }

    /**
     * 响应集合数据
     * @param data 结果集
     * @param <T> 集合类型
     */
    public static <T> MultiVO<T> multi(Collection<T> data)
    {
        return multi(ResultEnum.SUCCESS.getMessage(),data);
    }

    /**
     * 响应集合数据
     * @param message 提示信息
     * @param data 结果集
     * @param <T> 集合类型
     */
    public static <T> MultiVO<T> multi(String message,Collection<T> data)
    {
        return multi(ResultEnum.SUCCESS.getCode(),message,data);
    }

    /**
     * 响应集合数据
     * @param baseEnum 枚举值
     * @param data 结果集
     * @param <T> 集合类型
     */
    public static <T> MultiVO<T> multi(BaseEnum baseEnum,Collection<T> data)
    {
        return multi(baseEnum.getCode(),baseEnum.getMessage(),data);
    }

    /**
     * 响应集合数据
     * @param code 状态码
     * @param message 提示信息
     * @param data 结果集
     * @param <T> 集合类型
     */
    public static <T> MultiVO<T> multi(String code,String message,Collection<T> data)
    {
        MultiVO<T> tMultiVO = new MultiVO<>();
        tMultiVO.setCode(code);
        tMultiVO.setMessage(message);
        tMultiVO.setData(data);
        return tMultiVO;
    }

    /**
     * 响应单体数据
     * @param data 结果
     * @param <T> 结果类型
     */
    public static <T> SingleVO<T> single(T data)
    {
        return single(ResultEnum.SUCCESS.getMessage(),data);
    }

    /**
     * 响应单体数据
     * @param message 提示信息
     * @param data 结果
     * @param <T> 结果类型
     */
    public static <T> SingleVO<T> single(String message,T data)
    {
        return single(ResultEnum.SUCCESS.getCode(),message,data);
    }

    /**
     * 响应单体数据
     * @param baseEnum 枚举值
     * @param data 结果
     * @param <T> 结果类型
     */
    public static <T> SingleVO<T> single(BaseEnum baseEnum,T data)
    {
        return single(baseEnum.getCode(),baseEnum.getMessage(),data);
    }

    /**
     * 响应单体数据
     * @param code 状态码
     * @param message 提示信息
     * @param data 结果
     * @param <T> 结果类型
     */
    public static <T> SingleVO<T> single(String code,String message,T data)
    {
        SingleVO<T> tSingleVO = new SingleVO<>();
        tSingleVO.setCode(code);
        tSingleVO.setMessage(message);
        tSingleVO.setData(data);
        return tSingleVO;
    }

    /**
     * 响应分页数据
     * @param pages 分页数据信息
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(Pages<T> pages)
    {
        return page(ResultEnum.SUCCESS.getMessage(),pages);
    }

    /**
     * 响应分页数据
     * @param pageInfo 分页信息
     * @param data 分页数据集
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(PageInfo pageInfo, Collection<T> data)
    {
        return page(ResultEnum.SUCCESS.getMessage(),pageInfo,data);
    }

    /**
     * 响应分页数据
     * @param message 提示信息
     * @param pages 分页数据信息
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(String message,Pages<T> pages)
    {
        return page(ResultEnum.SUCCESS.getCode(),message,pages);
    }

    /**
     * 响应分页数据
     * @param message 提示信息
     * @param pageInfo 分页信息
     * @param data 分页数据集
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(String message,PageInfo pageInfo,Collection<T> data)
    {
        return page(ResultEnum.SUCCESS.getCode(),message,pageInfo,data);
    }

    /**
     * 响应分页数据
     * @param baseEnum 枚举值
     * @param pages 分页数据信息
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(BaseEnum baseEnum,Pages<T> pages)
    {
        return page(baseEnum.getCode(),baseEnum.getMessage(),pages);
    }


    /**
     * 响应分页数据
     * @param baseEnum 枚举值
     * @param pageInfo 分页信息
     * @param data 分页数据集
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(BaseEnum baseEnum,PageInfo pageInfo,Collection<T> data)
    {
        return page(baseEnum.getCode(),baseEnum.getMessage(),pageInfo,data);
    }

    /**
     * 响应分页数据
     * @param code 状态码
     * @param message 提示信息
     * @param pages 分页数据信息
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(String code,String message,Pages<T> pages)
    {
        PageInfo pageInfo = PageInfo.builder()
                .page(pages.getPage())
                .pages(pages.getPage())
                .size(pages.getSize())
                .total(pages.getTotal())
                .build();
        return page(code,message,pageInfo,pages.getData());
    }

    /**
     * 响应分页数据
     * @param code 状态码
     * @param message 提示信息
     * @param pageInfo 分页信息
     * @param data 分页数据集
     * @param <T> 数据类型
     */
    public static <T> PageVO<T> page(String code,String message,PageInfo pageInfo,Collection<T> data)
    {
        PageVO<T> tPageVO = new PageVO<>();
        tPageVO.setCode(code);
        tPageVO.setMessage(message);
        tPageVO.setPageInfo(pageInfo);
        tPageVO.setData(data);
        return tPageVO;
    }
}
